(function(){
	'use strict';
	/**
	 * 直线图组件
	 * 
	 * Author : Vicco Wang
	 * Date : 2016.10.11
	 *
	 * Dependecy plugin:
	 * 
	 * [jQuery Base selector for angular]
	 * [Angular]
	 * [Velocity Animations]
	 * [zhxRingButtons]
	 * 
	 */
	var CTCMAP = angular.module('zhxCtcLineModule',['zhxCtcTemplate','zhx-ring-buttons','zhxLoadingModule']);

	/**
	 * 过滤 YYYY-MM-DD HH:SS:MM 格式为HH:SS:MM
	 */
	CTCMAP.filter('busTimeFilter',function(){
		return function(value){
			var arr = value.split(' ');
			return arr[1];
		}
	});

	/**
	 * 直线图组件通用服务工具服务
	 */
	CTCMAP.factory('zhxCtcLineUtils', ['$rootScope','$http','$q','$compile','$timeout',function($rootScope,$http,$q,$compile,$timeout){
		
		var service = {};

		//直线图组件默认配置项
		service.getNormalOpts = function(){

			var normalOpts = {
				//传递一个当前控制器的作用域，方便后面组件中使用
				scope : null,
				//线路数据
				lineData : null,
				//线路数据字段映射
				lineKeyMap : {},
				//车辆数据，每次推送1辆车数据，根据ID判断为新增车辆还是更新车辆[需要实时更新]
				busData : null,
				//车辆数据字段映射
				busKeyMap : {},
				//线路配置项 左上角车辆，上下行展示项
				lineOptsData : null,
				lineOptions : [],
				//控制区域按钮配置项，
				ctrlButtons : [],
				//线路支线标签页数据配置
				lineTab : null,
				lineTabOpts : {},
				//车辆点击后环状图标组按钮样式配置与事件配置
				//event事件可以直接在该控制器内定义
				//event事件接收两个参数，event对象和event按钮的scope对象
				busClickOpts : []
			};

			return normalOpts;

		};

		/**
		 * 数据字段与组件字段映射
		 * @param  {[type]} opts [description]
		 * @return {[type]}      [description]
		 */
		service.getKeyMap = function( opts ){
			var lineKeyMap = {
					upStationLineKey	: 'upStationList' ,
					downStationLineKey	: 'downStationList' ,
					stationIdKey		: 'station_uuid' ,
					positionKey			: 'position',
					stationNameKey		: 'station_name' ,
					statDistanceKey		: 'line_station_start_distance' ,
					isShowKey			: 'line_station_is_show'
				},
				busKeyMap = {
					lineTypeKey			: 'lineType',
					busIdKey			: 'busUuid',
					busNoKey			: 'busPlate',
					rateKey 			: 'rate',
					driverNameKey		: 'driverName',
					busStatusKey		: 'status',
					busSpeedKey			: 'busSpeed',
					fullLoadRateKey		: 'fullLoadRate',
					alarmMsgKey			: 'alarmMsg',
					busShiftKey			: 'shift',
					busTripKey			: 'trip',
					nextStationKey		: 'nextStation',
					operationKey		: 'operation',
					planTimeKey			: 'planTime',
					startTimeKey		: 'startTime',
					forecastTimeKey		: 'forecastTime',
					forecastMsgKey		: 'forecastMsg',
					tripDateKey			: 'tripDate',
					lastStationNumKey	: 'lastStationNum',
					lastUpdateTimeKey	: 'lastUpdateTime'
				},
				keyMap = {
					lineKeyMap : angular.extend( {}, lineKeyMap, opts.lineKeyMap ),
					busKeyMap  : angular.extend( {}, busKeyMap , opts.busKeyMap )
				};

			return keyMap;

		};

		//重构线路站点[非车辆]位置为百分比
		service.getRenderStationLineData = function( stationLineData, lineKeyMap ){
			var i = 0,stationLineDataLen = stationLineData.length;
			if( !stationLineDataLen ) return;
			for( ; i < stationLineDataLen; i++ ){
				var station = stationLineData[i];
				station.__relativePos = parseFloat( station[lineKeyMap.positionKey] * 100 ).toFixed(1) + '%';
			}
			return stationLineData;
		};

		/**
		 * 在每次向车辆数组中添加展示数据时，应先应用该方法来重构一些数据
		 * 目前这里为数据对象中新增一条百分比位置信息来进行位置绘制
		 * PS：这里的数据不需要循环，因为数据一次只会推送一条
		 */
		service.getRenderBusData = function( updateBus, busKeyMap, onLineBusArr, elementWrapper ){
			if( !angular.isObject( updateBus ) ) return;
			//获取当前线路总宽度PX,仅用来计算相对位置
			var busLineWidth = parseInt( elementWrapper.find('.ctc-liear-line').outerWidth() );
			//设置一个位置渲染百分比
			updateBus.__relativePos = (updateBus[busKeyMap.rateKey] * 100).toFixed(1) + '%';
			//设置像素级的相对位置，此位置不做渲染用，仅仅用来判断车辆位置是否重叠之使用
			updateBus.__relativePosPx = parseInt( updateBus[busKeyMap.rateKey] * busLineWidth );
			//默认车辆渲染在-30像素位置（初始高度）
			updateBus.__relativeTop = -30;

			var onLineBusArrLen = onLineBusArr.length;

			/**
			 * 修正位置重叠，循环当前线路（上行或下行）上所有车辆对象，进行比对。如果位置相差18像素以内则表示重叠（保证在同一高度下重叠，不同位置高度不需要判断是否重叠）
			 * 重叠的车高度会递增25像素
			 * @param  {[type]} i [description]
			 * @return {[type]}   [description]
			 *
			 *	该方法因为仅做单次循环比较,不准确,先停用
			 * 
			 */
			// for( var i = 0; i < onLineBusArrLen; i++ ){
			// 	var srcBus = onLineBusArr[i],
			// 		distance = Math.abs( parseInt(srcBus.__relativePosPx) - parseInt(updateBus.__relativePosPx) );
			// 	if( distance <= 18 && srcBus.__relativeTop == updateBus.__relativeTop && srcBus[busKeyMap.busIdKey] !== updateBus[busKeyMap.busIdKey] ){
			// 		updateBus.__relativeTop -= 25;
			// 	}
			// }

			/**
			 * 修正位置重叠，循环当前线路（上行或下行）上所有车辆对象，进行比对。如果位置相差18像素以内则表示重叠（保证在同一高度下重叠，不同位置高度不需要判断是否重叠）
			 * 重叠的车高度会递增25像素
			 * TODO发现极低机率会在4-5辆车相互有叠加位置情况下出现重叠现象
			 */
			for( var j = 0; j < onLineBusArrLen; j++ ){
				var arrBus = onLineBusArr[j];
					arrBus.__relativeTop = -30;
				for( var t = 0; t < onLineBusArrLen; t++ ){
					var distBus = onLineBusArr[t];
					//不和自己比较
					if( arrBus[busKeyMap.busIdKey] === distBus[busKeyMap.busIdKey] ) break;
					//计算数组中两辆车之间的位置
					var distance = Math.abs( parseInt(arrBus.__relativePosPx) - parseInt(distBus.__relativePosPx) );
					if( distance < 16 && arrBus.__relativeTop === distBus.__relativeTop ){
						arrBus.__relativeTop -= 25;
					}
				}

			}

			return updateBus;
		};

		/**
		 * 在某些情况下,比如窗口缩放时,需要重新计算直线图上车辆的相对位置.
		 * 因为相对位置是以像素为单位进行的内部计算,所以在每次窗口缩放后,需要重新进行计算.
		 * 该方法一般在直线图父指令中进行绑定
		 * @param  {[type]} busArrayObject [description]
		 * @param  {[type]} busKeyMap      [description]
		 * @param  {[type]} elementWrapper [description]
		 * @return {[type]}                [description]
		 */
		service.updateOnlineBusPos = function(busArrayObject,busKeyMap, elementWrapper){

			angular.forEach(busArrayObject,function(busArray, arrName){
				//只计算直线图上车辆的位置
				if( arrName === 'upLineBus' || arrName === 'downLineBus' ){
					var busLineWidth = parseInt( elementWrapper.find('.ctc-liear-line').outerWidth() ),
						i, busArrLen = busArray.length;
					for( i = 0; i < busArrLen; i++){
						var bus = busArray[i];
						//设置像素级的相对位置，此位置不做渲染用，仅仅用来判断车辆位置是否重叠之使用
						bus.__relativePosPx = parseInt( bus[busKeyMap.rateKey] * busLineWidth );
					}
					// console.log('重新计算位置.');
				}
			});

		};

		/**
		 * 根据某一个ObjectkEY来判断某一个对象是否在一个数组对象中存在
		 */
		// service.objNotInArray = function(object, distArr, key){
		// 	if( !angular.isObject(object) || !angular.isArray(distArr) ) return;
		// 	var i = 0, distArrLen = distArr.length, isInArray = false;
		// 	for(; i < distArrLen; i++ ){
		// 		if( object[key] === distArr[i][key] ){
		// 			isInArray = true;
		// 			break;
		// 		} 
		// 	}
		// 	return isInArray;
		// };

		/**
		 * 创建一个弹出层，共日历扩展使用（左右键点击等等）
		 * @param  {[type]} event      [widnow事件对象]
		 * @param  {[type]} dom        [一个HTML字符串，可以直接添加进弹出层中]
		 * @param  {[type]} compileScp [作用域，传递了该作用域后则会进行Angular编译]
		 * @param  {[type]} isolate    [是否为独立作用域，如果使用了独立作用域，则在移除弹出层时会自动销毁该作用域]
		 * @return {[type]}            [一个编译否的弹出层对象]
		 */
		service.createLayer = function(event, dom, compileScp, isolate, rendX, rendY ){

			var ev = event || window.event,
				x = ev.pageX,
				y = ev.pageY,
				rendX = rendX || 0, rendY = rendY || 0,
				dw = document.documentElement.clientWidth,
				dh = document.documentElement.clientHeight,
				layers = angular.element('.zhx-ctc-layer');

			var isCreated = layers.length ? true : false;	

			var __createLayer = function(){

				var layerDom = angular.element('<div class="zhx-ctc-layer"></div>');

				return layerDom;
			};

			var __renderLayer = function(layer){
				if( isCreated ){
					layer.empty();
				}
				//将DOM模板放入LAYER中
				dom && layer.append(dom);
				//如果启用编译，则使用angular进行编译处理
				compileScp && $compile(layer)(compileScp);

				//声明一个移除LAYER方法
				compileScp.removeLayer = function(){
					layer.velocity({
						scale : 0,
						opacity : 0
					},{
						duration : 120,
						complete : function( ele ){
							$timeout(function(){
								layer.remove();
								isolate && compileScp.$destroy();
								angular.element('body').off('click',compileScp.removeLayer);
							},120);
						}
					});
				};

				//绑定一个接收事件，如果外部手动需要关闭，可以传递该事件关闭当前layer
				compileScp.$on('zhx.ctc.layer.close',function(ev,res){
					compileScp.removeLayer();
				});
				//给BODY绑定一个移除LAYER的事件
				angular.element('body').on('click',compileScp.removeLayer);

				//为LAYER设定具体弹出位置
				$timeout(function(){

					var layerHeight = layer.outerHeight() || layer[0].clientHeight,
						layerWidth = layer.outerWidth() || layer[0].clientWidth,
						offsetHeight = dh - layerHeight,
						offsetWidth = dw - layerWidth;

					//防止LAYER溢出屏幕	
					layer.css({ top : offsetHeight - y < 10 ? offsetHeight - 10 + rendY : y + rendY, left : offsetWidth - x < 10 ?  offsetWidth - 10 + rendX : x + rendX });
					layer.velocity({
						scale : 1,
						opacity : .96
					}, 120 );

				});

				return layer;

			};


			if( !isCreated ) var layer = __createLayer();
				
			return __renderLayer( layer || layers );

		};

		return service;

	}]);

	/**
	 * 直线图总控制器,负责直线图部分框架配置
	 * 名称配置、信息配置、控制按钮配置、
	 * 基础内容初始化
	 */
	CTCMAP.controller('zhxCtcLineController',['$rootScope','$scope','$element','zhxCtcLineUtils','$q','$http',function($rootScope,$scope,$element,zhxCtcLineUtils,$q,$http){

		var $stationLine = this;
		//获取用户配置项
		var options = angular.extend( {}, zhxCtcLineUtils.getNormalOpts() , $scope.options );
		//获取自定义字段映射
		var keyMap = zhxCtcLineUtils.getKeyMap(options);
		//声明线路字段映射
		$scope.__lineKeyMap = keyMap.lineKeyMap;
		//声明车辆字段映射
		$scope.__busKeyMap = keyMap.busKeyMap;
		//获取组件右上角展示的控制按钮部分
		$scope.ctrlButtons = $scope.options.ctrlButtons;
		//RINGSBUTTON 点击后的车辆对象
		//该车辆在点击后不能再进行移动
		$scope.ringsBtnCtrlBusId = null;
		$scope.ringsBtnTemBusData = null;
		//配置子线路标签
		$scope.lineActiveTab = null;	//当前激活的子线路TAB ID
		$scope.lineTabOpts = options.lineTabOpts;	//子线路TAB配置项

		/**
		 * 该对象需要被watch并实时更新
		 * @type {Object}
		 */
		$scope.__lineBusArrObject = {
			//上行线上车辆
			upLineBus : [],
			//下行线上车辆
			downLineBus : [],
			//上行待发车辆数组
			upReadyBus : [],
			//下行待发车辆数组
			downReadyBus : [],
			//上行非运营数组
			upNonServiceBus : [],
			//下行非运营数组
			downNonServiceBus : [],
			//离线车辆数组
			offLineBus : [],
			//停运车辆数组
			stopServiceBus : []
		};

		//复制出一份空对象，在切换线路时可以重置车辆对象
		var resetLineBusObj = angular.copy($scope.__lineBusArrObject);

		//获取站点线路信息
		$stationLine.getLineData = function(){
			return $scope.options.lineData;
		};

		//获得组件祖先作用域，也就是总控制器作用域
		$stationLine.getRootScope = function(){
			return $scope.options.scope || $scope.$parent;
		};

		//切换线路
		$stationLine.changeStationLine = function(line){
			//清空目前各位置车辆信息
			var tempObj = angular.copy( resetLineBusObj );
			$scope.__lineBusArrObject = tempObj;
			$rootScope.$broadcast('zhx.ctc.changeStationLine',{ stationLine : line });
		};

		//切换子线路
		$stationLine.changeSubLine = function(line){
			//清空目前各位置车辆信息
			var tempObj = angular.copy( resetLineBusObj );
			$scope.__lineBusArrObject = tempObj;

			//获取组件根作用域
			var rootScope = $stationLine.getRootScope();
			//调用用户设定的切换方法
			//为用户抛出当前选择的线路对象 line
			try{
				rootScope[ $scope.lineTabOpts.event ].call( this, line );
				//设置当前激活的子线路样式
				$scope.lineActiveTab = line[ $scope.lineTabOpts.id ];
			} catch(e){
				console.warn('未定义tab线路标签的event事件');
			}

		};

		/**
		 * 更新车辆变化，推送车辆信息后也执行该方法来渲染页面车辆位置与数据信息
		 */
		//
		// var debugNum = 0;
		$stationLine.updateBus = function(busObject){
			var busKeyMap = keyMap.busKeyMap,
				busLineType = busObject[busKeyMap.lineTypeKey],
				busId  = busObject[busKeyMap.busIdKey],
				status = busObject[busKeyMap.busStatusKey];

			var willUpdateArrObject;

			//如果要更新的车辆已经激活圆环按钮群，则暂时不更新当前车辆位置信息
			if( $scope.ringsBtnCtrlBusId ){
				if( $scope.ringsBtnCtrlBusId === busId ) return;
			}

			// console.log(debugNum  +  '	', 'Rate: ', busObject[busKeyMap.rateKey], 'Status: ', busObject[busKeyMap.busStatusKey]);
			// debugNum++;

			//更新数据以busID为基准进行检测，如果一样则更新，不一样则添加
			var __updateInArray = function(arr){

				var flag = false, lineBusFlag = false, arrLen = arr.length;

				//检查更新车辆与数组进行比对
				for( var i = 0 ; i < arrLen; i++ ){
					if( busId === arr[i][busKeyMap.busIdKey] ){
						//也许需要merge or extend ?
						arr.splice(i,1,busObject);
						flag = !flag;
						break;
					}
				}

				//全部状态车辆数组循环,与当前需要更新的车辆进行比对,如果状态不一样且ID一样,则从该数组中移除
				//TODO这里需要真实数据联调测试
				angular.forEach($scope.__lineBusArrObject, function(busArr,arrName){

					if( lineBusFlag || !busArr.length ) return;
					for( var t = 0 ; t < busArr.length; busArr++ ){
						if( busId === busArr[t][busKeyMap.busIdKey] && status !== busArr[t][busKeyMap.busStatusKey] ){
								$scope.__lineBusArrObject[arrName].splice( t , 1 );
								lineBusFlag = !lineBusFlag;
								break;
						}
					}	
				});

				if( flag ) return;
				//如果为新车,则直接添加至对应数组中
				arr.push(busObject);

			};
			//在线，在线车辆需要计算相对位置，故这里先更新数组，然后再执行相对位置的计算
			if( status == "0" ){ 
				willUpdateArrObject = busLineType == "1" ? $scope.__lineBusArrObject.upLineBus : $scope.__lineBusArrObject.downLineBus; 
				//在线车辆位置信息更新,并修正位置重叠
				__updateInArray( willUpdateArrObject );
				zhxCtcLineUtils.getRenderBusData( busObject, $scope.__busKeyMap, willUpdateArrObject , $element );
				return;
			}
			//待发
			else if( status == "1" ){ willUpdateArrObject = busLineType == "1" ? $scope.__lineBusArrObject.upReadyBus : $scope.__lineBusArrObject.downReadyBus; }
			//离线
			else if( status == "8" ){ willUpdateArrObject = $scope.__lineBusArrObject.offLineBus; }
			//停运
			else if( status == "9" ){ willUpdateArrObject = $scope.__lineBusArrObject.stopServiceBus; }
			//非运营 其他
			else { willUpdateArrObject = busLineType == "1" ? $scope.__lineBusArrObject.upNonServiceBus : $scope.__lineBusArrObject.downNonServiceBus; }
			//确认更新数组后更新车辆数组
			__updateInArray( willUpdateArrObject );

		};

		//获取线路信息KEYMAP
		$stationLine.getLineKeyMap = function(){
			return keyMap.lineKeyMap;
		};
		//获取车辆信息KEYMAP
		$stationLine.getBusKeyMap = function(){
			return keyMap.busKeyMap;
		};
		//获取车辆点击圆环按钮群信息
		$stationLine.getBusClickOpts = function(){
			return $scope.options.busClickOpts || [];
		};

		//车辆圆环按钮打开后将固定当前选择的车辆
		//固定车辆是因为有可能在圆环按钮打开后，车辆在直线图上移动，影响环绕效果
		$scope.$on('zhx.ringsbutton.opened',function(ev,data){
			var busId = data.targetData[$scope.__busKeyMap.busIdKey];
			if( busId ) $scope.ringsBtnCtrlBusId = busId;
		});

		//车辆圆环按钮关闭后将当前固定的车辆释放，释放后，该车辆在此期间移动的位置将会更新
		$scope.$on('zhx.ringsbutton.closed',function(ev,data){
			var busId = data.targetData[$scope.__busKeyMap.busIdKey];
			if( busId ) {
				$scope.ringsBtnCtrlBusId = null;
				 //RINGS BUTTON关闭后更新车辆信息
				if( $scope.ringsBtnTemBusData ) {
					$stationLine.updateBus( $scope.ringsBtnTemBusData );
				}
			}	
		});

		//监控线路TAB标签（子线路）数据
		$scope.$watch('options.lineTab',function(nv,ov){
			if( nv && nv !== ov ){
				$scope.lineTab = nv;
				//设置第一个为active样式
				$scope.lineActiveTab = nv[0][ $scope.lineTabOpts.id ];
			}
		})

		//设置一个线路站点信息的监控[左上角线路名称旁边的信息]
		$scope.$watch('options.lineOptsData',function(nv,ov){
			if( nv && nv !== ov){
				$scope.lineStationInfo = nv;
				$scope.lineStationOpts = $scope.options.lineOptions;
			}
		});

		//监控车辆推送数据，进行实时更新
		$scope.$watch('options.busData',function(nv,ov){
			if( nv !== ov && nv ){
				 $stationLine.updateBus(nv);
				 //如果当前触发了RINGS BUTTON，则需要将当前数据先暂存，等RINGS BUTTON关闭后再进行更新
				if( $scope.ringsBtnCtrlBusId ){
					if( $scope.ringsBtnCtrlBusId === nv[$scope.__busKeyMap.busIdKey] ){
						$scope.ringsBtnTemBusData = nv;
					}
				}
			};
		});

	}]);

	/**
	 * 组件父指令,提供公共方法和一些全局事件绑定
	 */
	CTCMAP.directive('zhxCtcLine',['$compile','zhxCtcLineUtils','$timeout','$rootScope',function($compile,zhxCtcLineUtils,$timeout,$rootScope){
		return {
			restrict : 'E',
			scope : {
				options : '='
			},
			replace : true,
			controller : 'zhxCtcLineController',
			link : function( scope, tElement, tAttrs, $stationLine ){

				//功能按钮区(顶部右边)按钮事件绑定
				scope.ctrlBtnClick = function(event,$index){
					var ev = event || window.event,
						parentScope = $stationLine.getRootScope();
					try{
						parentScope[ scope.ctrlButtons[$index].event ].call(this, scope.lineData, ev);
					}catch(e){
						console.warn('未定义事件或方法出错', e);
					}
				};

				//站名点击切换线路
				scope.changeLine = function(){

					// $stationLine.changeStationLine();

					var headerTab = angular.element('.zhx-ctc-line-tab');

					if( headerTab.attr('isopen') ){
						headerTab.velocity({
							height : 0
						},{
							duration : 200,
							easing : 'ease',
							complete : function(ele){
								angular.element(ele).removeAttr('isopen');
							}
						});
						return;
					}

					headerTab.velocity({
						height : 30
					},{
						duration : 200,
						easing : 'ease',
						complete : function(ele){
							angular.element(ele).attr('isopen',true);
						}
					})
				};

				//切换子线路
				scope.changeSubLine = function(ev,line){
					$stationLine.changeSubLine(line);
				};

				//为窗口绑定一个缩放事件,在缩放后,直线图上的车辆需要重新进行位置计算(仅计算相对位置)
				window.addEventListener('resize', function(){
					zhxCtcLineUtils.updateOnlineBusPos( scope.__lineBusArrObject, scope.__busKeyMap, tElement );
				});

			},
			templateUrl : 'zhx.ctc.template.vicco'
		}
	}]);

	/**
	 * 直线图指令
	 */
	CTCMAP.directive('zhxCtcLiearMap',['$rootScope','zhxCtcLineUtils','$templateCache','$timeout',function($rootScope,zhxCtcLineUtils,$templateCache,$timeout){
		return{
			restrict: 'E',
			scope : true,
			replace: true,
			require : '^zhxCtcLine',
			link : function( scope, tElement, tAttrs, ctcLineStation ){

				//确认线路渲染时，先获取到线路站点信息
				scope.$watch(ctcLineStation.getLineData,function(lineStation,unLineStation){
					if( lineStation !== unLineStation ){
						//获取原始上下行线路站点数据
						var __preUpStationLineData = lineStation[scope.__lineKeyMap.upStationLineKey],
							__preDownStationLineData = lineStation[scope.__lineKeyMap.downStationLineKey];

						//对读取到的线路站点信息进行相对位置的百分比处理，然后再渲染到页面上
						scope.__upStationLineData = zhxCtcLineUtils.getRenderStationLineData( __preUpStationLineData, scope.__lineKeyMap );
						scope.__downStationLineData = zhxCtcLineUtils.getRenderStationLineData( __preDownStationLineData, scope.__lineKeyMap );

					};
				});
			
				//公用弹出框作用域
				var tipScp = scope.$new();
				//设置一个触发延迟
				//{promise}
				var hoverTimeout = null,
					leaveTimeout = null;

				//站点悬浮事件
				scope.showStationInfo = function(event,station){
					var ev = event || window.event,
						target = angular.element( ev.target );
						//use velocity animation
						target.velocity({ scale : 1.7 },100);

						if( leaveTimeout ) $timeout.cancel(leaveTimeout);	

					hoverTimeout = $timeout(function(){

						if( tipScp.$$destroyed ) tipScp = scope.$new();

						tipScp.station = station;

						var tipDom = $templateCache.get('zhx.ctc.liearMap.layer.station.vicco');

						var tip = zhxCtcLineUtils.createLayer(ev, tipDom, tipScp, true, -20, 15 );
						tip.appendTo( 'body' );

					},200);
				};

				//车辆悬浮
				scope.hoverBusInfo = function(event,bus){
					var ev = event || window.event,
						target = angular.element( ev.target );
						//use velocity animation
						target.velocity({ top : "-=2px", left : "-=3px", fontSize : '+=6px' },{ duration : 100 });

						if( leaveTimeout ) $timeout.cancel(leaveTimeout);

					hoverTimeout = $timeout(function(){

						if( tipScp.$$destroyed ) tipScp = scope.$new();

						tipScp.bus = bus;

						var tipDom = $templateCache.get('zhx.ctc.liearMap.layer.bus.vicco');

						var tip = zhxCtcLineUtils.createLayer(ev, tipDom, tipScp, true, 20, -10 );
						tip.appendTo( 'body' );
						
					},200);
				};

				//重置动画
				scope.finishAnimation = function(event){
					var ev = event || window.event,
						target = angular.element( ev.target );
						target.velocity("reverse");
					
					if( hoverTimeout ) $timeout.cancel( hoverTimeout );
					//鼠标移出目标后1秒隐藏弹出层
					leaveTimeout = $timeout(function(){
						$rootScope.$broadcast('zhx.ctc.layer.close');
					},1000);
				};

				//如果定义了车辆的RINGS BUTTON，则给车辆绑定点击事件
				var ringsButton = ctcLineStation.getBusClickOpts();
				if( ringsButton.length ){
					//配置车辆点击后展开的环状按钮群
					scope.ringOptions = {
						scope : ctcLineStation.getRootScope(),
						ringWraperRadius : 85,
						ringRadius : 45,
						duration : 35,
						styleClass : 'busActiveClass',
						broadcastEvent : 'zhx.ctc.layer.close',
						rings : ringsButton
					};	
				}
				
			},
			templateUrl : 'zhx.ctc.liearMap.vicco'
		}
	}]);

})()
